package com.sg.service.biz.component.impl;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollectionUtil;
import com.sg.common.util.CommonFunctionHelper;
import com.sg.common.util.RedisUtil;
import com.sg.dto.biz.component.req.*;
import com.sg.dto.biz.component.res.*;
import com.sg.service.biz.component.*;
import com.sg.common.exception.Assert;
import org.apache.skywalking.apm.toolkit.trace.Tag;
import org.apache.skywalking.apm.toolkit.trace.Tags;
import org.apache.skywalking.apm.toolkit.trace.Trace;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.stream.Collectors;

/**
 * @author ：
 * @version 1.0
 * @date ：
 */
@Service
public class ResourceFileServiceImpl
        implements com.wicket.okrcomponent.biz.service.ResourceFileService {

    @Resource
    private RedisUtil redisUtil;
    @Resource
    private BusinessAtomService businessAtomService;
    //@Resource
    //private MOmsResourceFileService mOmsResourceFileService;
//@Resource
    //private undefinedService undefinedService;
    @Resource
    private NetDiskService netDiskService;
    @Resource
    private InterfaceModeService interfaceModeService;
    @Resource
    private TemplateEngineService templateEngineService;
    //@Resource
    //private MSpecMethordTableService mSpecMethordTableService;
    @Resource
    private NbResourceFile nbResourceFile;
    @Resource
    private ConfSchemeService confSchemeService;
    //@Resource
    //private MCustomFields4Service mCustomFields4Service;
    @Resource
    private IntelligentCommunicationService intelligentCommunicationService;
//@Resource
    //private MCustomFields5Service mCustomFields5Service;
//@Resource
    //private MCustomFields6Service mCustomFields6Service;

    /**
     * D2删除REDIS物理文件记录(redis)(公共)[10407]
     * gen by moon at 12/4/2024, 7:23:28 AM
     */
    @Trace(operationName = "D2删除REDIS物理文件记录(redis)(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public DeletePhyFileRedisRecordComRespDto deletePhyFileRedisRecordCom(DeletePhyFileRedisRecordComReqDto reqDto) {


        //步骤0: D2删除redis业务数据对象(业务原子) - deleteRedisBusinessDataSetCom
        DeleteRedisBusinessDataSetComRespDto deleteRedisBusinessDataSetComRespDto = null;
        DeleteRedisBusinessDataSetComReqDto deleteRedisBusinessDataSetComReqDto = new DeleteRedisBusinessDataSetComReqDto();
        deleteRedisBusinessDataSetComReqDto.setRedisDataObjectCatalogue("物理文件记录");//sourceId:2029909_1
        deleteRedisBusinessDataSetComReqDto.setIsDataList("TRUE");//sourceId:2029911_1
        deleteRedisBusinessDataSetComReqDto.setCustomField1("physicalFilePath");//CUSTOM_CONVENTION//sourceId:2029912_1
        if (reqDto != null) {
            deleteRedisBusinessDataSetComReqDto.setBusinessDataObject(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:2029910_1
            deleteRedisBusinessDataSetComReqDto.setCustomFieldValue1(reqDto.getPhyFilePath());//SimpleFieldAssign//sourceId:2029913_1
        }

        /*D2删除redis业务数据对象(业务原子)[9717]   */
        Assert.isNull(deleteRedisBusinessDataSetComReqDto.getBusinessDataObject(), "D2删除REDIS物理文件记录(redis)(公共)-D2删除redis业务数据对象(业务原子)-业务数据对象不能为空", false);
        Assert.isNull(deleteRedisBusinessDataSetComReqDto.getRedisDataObjectCatalogue(), "D2删除REDIS物理文件记录(redis)(公共)-D2删除redis业务数据对象(业务原子)-Redis数据对象目录不能为空", false);
        Assert.isNull(deleteRedisBusinessDataSetComReqDto.getIsDataList(), "D2删除REDIS物理文件记录(redis)(公共)-D2删除redis业务数据对象(业务原子)-是否是数据集对象不能为空", false);
        deleteRedisBusinessDataSetComRespDto = businessAtomService.deleteRedisBusinessDataSetCom(deleteRedisBusinessDataSetComReqDto)/*vcase invoke isSameApp*/;


        DeletePhyFileRedisRecordComRespDto retData = new DeletePhyFileRedisRecordComRespDto();


        return retData;
    }

    /**
     * D2新增物理文件路径记录到缓存(redis)(公共)[10406]
     * gen by moon at 12/6/2024, 10:01:55 PM
     */
    @Trace(operationName = "D2新增物理文件路径记录到缓存(redis)(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public AddPhyFileToRedisComRespDto addPhyFileToRedisCom(AddPhyFileToRedisComReqDto reqDto) {


        //步骤0: D2-新增redis业务数据对象（业务原子） - addRedisBusinessDataSetCom
        AddRedisBusinessDataSetComRespDto addRedisBusinessDataSetComRespDto = null;
        AddRedisBusinessDataSetComReqDto addRedisBusinessDataSetComReqDto = new AddRedisBusinessDataSetComReqDto();
        addRedisBusinessDataSetComReqDto.setRedisDataObjectCatalogue("物理文件记录");//sourceId:2029877_1
        addRedisBusinessDataSetComReqDto.setIsDataList("TRUE");//sourceId:2029878_1
        addRedisBusinessDataSetComReqDto.setCustomField1("physicalFilePath");//CUSTOM_CONVENTION//sourceId:2029879_1
        addRedisBusinessDataSetComReqDto.setCustomField2("storageType");//CUSTOM_CONVENTION//sourceId:2029881_1
        if (reqDto != null) {
            addRedisBusinessDataSetComReqDto.setBusinessDataObject(reqDto.getBusinessDataObject());//SimpleFieldAssign//sourceId:2029876_1
            addRedisBusinessDataSetComReqDto.setCustomFieldValue1(reqDto.getPyhFilePath());//SimpleFieldAssign//sourceId:2029880_1
            addRedisBusinessDataSetComReqDto.setCustomFieldValue2(reqDto.getUploadType());//SimpleFieldAssign//sourceId:2029882_1
        }

        /*D2-新增redis业务数据对象（业务原子）[8399]   */
        Assert.isNull(addRedisBusinessDataSetComReqDto.getBusinessDataObject(), "D2新增物理文件路径记录到缓存(redis)(公共)-D2-新增redis业务数据对象（业务原子）-业务数据对象不能为空", false);
        Assert.isNull(addRedisBusinessDataSetComReqDto.getRedisDataObjectCatalogue(), "D2新增物理文件路径记录到缓存(redis)(公共)-D2-新增redis业务数据对象（业务原子）-Redis数据对象目录不能为空", false);
        Assert.isNull(addRedisBusinessDataSetComReqDto.getIsDataList(), "D2新增物理文件路径记录到缓存(redis)(公共)-D2-新增redis业务数据对象（业务原子）-是否是数据集对象不能为空", false);
        Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue1(), "D2新增物理文件路径记录到缓存(redis)(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段值1不能为空", false);
        Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue2(), "D2新增物理文件路径记录到缓存(redis)(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段值2不能为空", false);
        addRedisBusinessDataSetComRespDto = businessAtomService.addRedisBusinessDataSetCom(addRedisBusinessDataSetComReqDto)/*vcase invoke isSameApp*/;


        AddPhyFileToRedisComRespDto retData = new AddPhyFileToRedisComRespDto();


        return retData;
    }

    /**
     * D2循环生成资源文件相对路径并缓存相对路径(公共)[10413]
     * gen by moon at 12/8/2024, 3:23:18 AM
     */
    @Trace(operationName = "D2循环生成资源文件相对路径并缓存相对路径(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public LoopSetResourceFileComRespDto loopSetResourceFileCom(LoopSetResourceFileComReqDto reqDto) {


        QueryMemorysBusinessDataListComRespDto queryMemorysBusinessDataListComRespDto_1 = null;
//virtualUsage D2查询上传类型  73708
        QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto = null;
        QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto = new QueryConfItemMatchAnswerDetailComReqDto();
        queryConfItemMatchAnswerDetailComReqDto.setResultAspObjId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:2034226_1_73708
        queryConfItemMatchAnswerDetailComReqDto.setResultAspObjType("TENANT_SPACE");//sourceId:2034227_1_73708
        queryConfItemMatchAnswerDetailComReqDto.setConfItemCode("UPLOAD_TYPE");//CUSTOM_CONVENTION//sourceId:2034228_1_73708
        queryConfItemMatchAnswerDetailComReqDto.setIsPlatData("FALSE");//sourceId:2034229_1_73708

        /*D2查询上传类型[2486]   */
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getResultAspObjId(), "D2循环生成资源文件相对路径并缓存相对路径(公共)-D2查询上传类型-开通对象ID不能为空", false);
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getResultAspObjType(), "D2循环生成资源文件相对路径并缓存相对路径(公共)-D2查询上传类型-开通对象类型编码不能为空", false);
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getConfItemCode(), "D2循环生成资源文件相对路径并缓存相对路径(公共)-D2查询上传类型-配置项标识不能为空", false);
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getIsPlatData(), "D2循环生成资源文件相对路径并缓存相对路径(公共)-D2查询上传类型-是否标准答案不能为空", false);
        queryConfItemMatchAnswerDetailComRespDto = confSchemeService.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto)/*vcase invoke isSameApp*/;


//virtualUsage M2-执行资源文件【循环开始】（特殊方法）  73629
        //ModelCode: circulationCollections
        for (String circulationCollectionsRes : reqDto.getResourceFileList()) {

//virtualUsage D2执行上传文件名称转单字段(公共)  73683
            ImplementUploadFileNameToFieldComRespDto implementUploadFileNameToFieldComRespDto = null;
            ImplementUploadFileNameToFieldComReqDto implementUploadFileNameToFieldComReqDto = new ImplementUploadFileNameToFieldComReqDto();
            if (circulationCollectionsRes != null) {
                implementUploadFileNameToFieldComReqDto.setResourceFileName(circulationCollectionsRes);//SimpleFieldAssign//sourceId:2033732_1_73683
            }

            /*D2执行上传文件名称转单字段(公共)[10418]   */
            Assert.isNull(implementUploadFileNameToFieldComReqDto.getResourceFileName(), "D2循环生成资源文件相对路径并缓存相对路径(公共)-D2执行上传文件名称转单字段(公共)-资源文件名称不能为空", false);
            implementUploadFileNameToFieldComRespDto = netDiskService.implementUploadFileNameToFieldCom(implementUploadFileNameToFieldComReqDto)/*vcase invoke isSameApp*/;


//virtualUsage D2将系统当前日期转换为字符串  73635
            ImplementDateFormatComRespDto implementDateFormatComRespDto = null;
            ImplementDateFormatComReqDto implementDateFormatComReqDto = new ImplementDateFormatComReqDto();
            implementDateFormatComReqDto.setComTimeField(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:2031571_1_73635
            implementDateFormatComReqDto.setTimeFormatMode("yyyy");//CUSTOM_CONVENTION//sourceId:2031572_1_73635

            /*D2将系统当前日期转换为字符串[8203]   */
            Assert.isNull(implementDateFormatComReqDto.getComTimeField(), "D2循环生成资源文件相对路径并缓存相对路径(公共)-D2将系统当前日期转换为字符串-通用时间字段不能为空", false);
            Assert.isNull(implementDateFormatComReqDto.getTimeFormatMode(), "D2循环生成资源文件相对路径并缓存相对路径(公共)-D2将系统当前日期转换为字符串-时间格式模式不能为空", false);
            implementDateFormatComRespDto = interfaceModeService.implementDateFormatCom(implementDateFormatComReqDto)/*vcase invoke isSameApp*/;


            if ((reqDto != null && reqDto.getPlatformOrTenantDoc() != null && reqDto.getPlatformOrTenantDoc().equals("PLATFORM"))) {
                //if(D2循环生成资源文件相对路径并缓存相对路径(公共).平台或租户文档 等于 平台)  73630

                GenerateSemanticInstanceStoryComRespDto generateSemanticInstanceStoryComRespDto = null;
                if (implementDateFormatComRespDto != null) {
                    GenerateSemanticInstanceStoryComReqDto generateSemanticInstanceStoryComReqDto = new GenerateSemanticInstanceStoryComReqDto();
                    generateSemanticInstanceStoryComReqDto.setTemplateSemanticEngineCode("PLATFORM_DOCUMENT_RELATIVE_PATH");//CUSTOM_CONVENTION//sourceId:2031545_1_73632
                    generateSemanticInstanceStoryComReqDto.setFirstFieldName("platformOrTenantDoc");//CUSTOM_CONVENTION//sourceId:2031539_1_73632
                    generateSemanticInstanceStoryComReqDto.setSecondFieldName("docUseType");//CUSTOM_CONVENTION//sourceId:2031541_1_73632
                    generateSemanticInstanceStoryComReqDto.setThirdFieldName("comTxtField");//CUSTOM_CONVENTION//sourceId:2031543_1_73632
                    if (reqDto != null) {
                        generateSemanticInstanceStoryComReqDto.setFirstFieldValue(reqDto.getPlatformOrTenantDoc());//SimpleFieldAssign//sourceId:2031540_1_73632
                        generateSemanticInstanceStoryComReqDto.setSecondFieldValue(reqDto.getDocUseType());//SimpleFieldAssign//sourceId:2031542_1_73632
                    }
                    if (implementDateFormatComRespDto != null) {
                        generateSemanticInstanceStoryComReqDto.setThirdFieldValue(implementDateFormatComRespDto.getComTxtField());//SimpleFieldAssign//sourceId:2031544_1_73632
                    }

                    /*D2生成平台文档相对路径[8234]   */
                    Assert.isNull(generateSemanticInstanceStoryComReqDto.getTemplateSemanticEngineCode(), "D2循环生成资源文件相对路径并缓存相对路径(公共)-D2生成平台文档相对路径-模板引擎标识不能为空", false);
                    Assert.isNull(generateSemanticInstanceStoryComReqDto.getFirstFieldName(), "D2循环生成资源文件相对路径并缓存相对路径(公共)-D2生成平台文档相对路径-第一个字段字段名不能为空", false);
                    Assert.isNull(generateSemanticInstanceStoryComReqDto.getFirstFieldValue(), "D2循环生成资源文件相对路径并缓存相对路径(公共)-D2生成平台文档相对路径-第一个字段字段值不能为空", false);
                    Assert.isNull(generateSemanticInstanceStoryComReqDto.getSecondFieldName(), "D2循环生成资源文件相对路径并缓存相对路径(公共)-D2生成平台文档相对路径-第二个字段字段名不能为空", false);
                    Assert.isNull(generateSemanticInstanceStoryComReqDto.getSecondFieldValue(), "D2循环生成资源文件相对路径并缓存相对路径(公共)-D2生成平台文档相对路径-第二个字段字段值不能为空", false);
                    Assert.isNull(generateSemanticInstanceStoryComReqDto.getThirdFieldName(), "D2循环生成资源文件相对路径并缓存相对路径(公共)-D2生成平台文档相对路径-第三个字段字段名不能为空", false);
                    Assert.isNull(generateSemanticInstanceStoryComReqDto.getThirdFieldValue(), "D2循环生成资源文件相对路径并缓存相对路径(公共)-D2生成平台文档相对路径-第三个字段字段值不能为空", false);
                    generateSemanticInstanceStoryComRespDto = templateEngineService.generateSemanticInstanceStoryCom(generateSemanticInstanceStoryComReqDto)/*vcase invoke isSameApp*/;


                }
                GenerateSemanticInstanceStoryComRespDto generateSemanticInstanceStoryComRespDto_2 = null;
                if (generateSemanticInstanceStoryComRespDto != null && implementUploadFileNameToFieldComRespDto != null) {
                    GenerateSemanticInstanceStoryComReqDto generateSemanticInstanceStoryComReqDto_1 = new GenerateSemanticInstanceStoryComReqDto();
                    generateSemanticInstanceStoryComReqDto_1.setTemplateSemanticEngineCode("CONCAT_FILE_PATH");//CUSTOM_CONVENTION//sourceId:2033692_1_73681
                    generateSemanticInstanceStoryComReqDto_1.setFirstFieldName("resourceFileRelaPath");//CUSTOM_CONVENTION//sourceId:2033686_1_73681
                    generateSemanticInstanceStoryComReqDto_1.setSecondFieldName("phyFileUuid");//CUSTOM_CONVENTION//sourceId:2033688_1_73681
                    generateSemanticInstanceStoryComReqDto_1.setThirdFieldName("resourceFileExtension");//CUSTOM_CONVENTION//sourceId:2033690_1_73681
                    if (generateSemanticInstanceStoryComRespDto != null) {
                        generateSemanticInstanceStoryComReqDto_1.setFirstFieldValue(generateSemanticInstanceStoryComRespDto.getObjectName());//SimpleFieldAssign//sourceId:2033687_1_73681
                    }
                    if (implementUploadFileNameToFieldComRespDto != null) {
                        generateSemanticInstanceStoryComReqDto_1.setSecondFieldValue(implementUploadFileNameToFieldComRespDto.getPhyFileUuid());//SimpleFieldAssign//sourceId:2033689_1_73681
                        generateSemanticInstanceStoryComReqDto_1.setThirdFieldValue(implementUploadFileNameToFieldComRespDto.getResourceFileExtension());//SimpleFieldAssign//sourceId:2033691_1_73681
                    }

                    /*D2拼接文件路径[8234]   */
                    Assert.isNull(generateSemanticInstanceStoryComReqDto_1.getTemplateSemanticEngineCode(), "D2循环生成资源文件相对路径并缓存相对路径(公共)-D2拼接文件路径-模板引擎标识不能为空", false);
                    Assert.isNull(generateSemanticInstanceStoryComReqDto_1.getFirstFieldName(), "D2循环生成资源文件相对路径并缓存相对路径(公共)-D2拼接文件路径-第一个字段字段名不能为空", false);
                    Assert.isNull(generateSemanticInstanceStoryComReqDto_1.getFirstFieldValue(), "D2循环生成资源文件相对路径并缓存相对路径(公共)-D2拼接文件路径-第一个字段字段值不能为空", false);
                    Assert.isNull(generateSemanticInstanceStoryComReqDto_1.getSecondFieldName(), "D2循环生成资源文件相对路径并缓存相对路径(公共)-D2拼接文件路径-第二个字段字段名不能为空", false);
                    Assert.isNull(generateSemanticInstanceStoryComReqDto_1.getSecondFieldValue(), "D2循环生成资源文件相对路径并缓存相对路径(公共)-D2拼接文件路径-第二个字段字段值不能为空", false);
                    Assert.isNull(generateSemanticInstanceStoryComReqDto_1.getThirdFieldName(), "D2循环生成资源文件相对路径并缓存相对路径(公共)-D2拼接文件路径-第三个字段字段名不能为空", false);
                    Assert.isNull(generateSemanticInstanceStoryComReqDto_1.getThirdFieldValue(), "D2循环生成资源文件相对路径并缓存相对路径(公共)-D2拼接文件路径-第三个字段字段值不能为空", false);
                    generateSemanticInstanceStoryComRespDto_2 = templateEngineService.generateSemanticInstanceStoryCom(generateSemanticInstanceStoryComReqDto_1)/*vcase invoke isSameApp*/;


                }
                AddMemoryBusiness2DataComRespDto addMemoryBusiness2DataComRespDto = null;
                if (generateSemanticInstanceStoryComRespDto_2 != null) {
                    AddMemoryBusiness2DataComReqDto addMemoryBusiness2DataComReqDto = new AddMemoryBusiness2DataComReqDto();
                    addMemoryBusiness2DataComReqDto.setIsDataList("TRUE");//sourceId:2033683_1_73679
                    addMemoryBusiness2DataComReqDto.setCustomField1("resourceFileRelaPath");//CUSTOM_CONVENTION//sourceId:2033684_1_73679
                    if (reqDto != null) {
                        addMemoryBusiness2DataComReqDto.setBusinessDataObject(reqDto.getPlatformOrTenantDoc());//SimpleFieldAssign//sourceId:2033682_1_73679
                        addMemoryBusiness2DataComReqDto.setDataObjectBatchCode(reqDto.getDocUseType());//SimpleFieldAssign//sourceId:2033681_1_73679
                    }
                    if (generateSemanticInstanceStoryComRespDto_2 != null) {
                        addMemoryBusiness2DataComReqDto.setCustomFieldValue1(generateSemanticInstanceStoryComRespDto_2.getObjectName());//SimpleFieldAssign//sourceId:2033685_1_73679
                    }

                    /*D2新增内存业务数据(业务原子)[9751]   */
                    Assert.isNull(addMemoryBusiness2DataComReqDto.getBusinessDataObject(), "D2循环生成资源文件相对路径并缓存相对路径(公共)-D2新增内存业务数据(业务原子)-业务数据对象不能为空", false);
                    Assert.isNull(addMemoryBusiness2DataComReqDto.getDataObjectBatchCode(), "D2循环生成资源文件相对路径并缓存相对路径(公共)-D2新增内存业务数据(业务原子)-数据对象批次标识不能为空", false);
                    Assert.isNull(addMemoryBusiness2DataComReqDto.getIsDataList(), "D2循环生成资源文件相对路径并缓存相对路径(公共)-D2新增内存业务数据(业务原子)-是否是数据集对象不能为空", false);
                    Assert.isNull(addMemoryBusiness2DataComReqDto.getCustomField1(), "D2循环生成资源文件相对路径并缓存相对路径(公共)-D2新增内存业务数据(业务原子)-自定义字段1不能为空", false);
                    Assert.isNull(addMemoryBusiness2DataComReqDto.getCustomFieldValue1(), "D2循环生成资源文件相对路径并缓存相对路径(公共)-D2新增内存业务数据(业务原子)-自定义字段值1不能为空", false);
                    addMemoryBusiness2DataComRespDto = businessAtomService.addMemoryBusiness2DataCom(addMemoryBusiness2DataComReqDto)/*vcase invoke isSameApp*/;


                }
                AddPhyFileToRedisComRespDto addPhyFileToRedisComRespDto = null;
                if (generateSemanticInstanceStoryComRespDto != null && queryConfItemMatchAnswerDetailComRespDto != null) {
                    AddPhyFileToRedisComReqDto addPhyFileToRedisComReqDto = new AddPhyFileToRedisComReqDto();
                    if (reqDto != null) {
                        addPhyFileToRedisComReqDto.setBusinessDataObject(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:2031580_1_73636
                    }
                    if (generateSemanticInstanceStoryComRespDto != null) {
                        addPhyFileToRedisComReqDto.setPyhFilePath(generateSemanticInstanceStoryComRespDto.getObjectName());//SimpleFieldAssign//sourceId:2031581_1_73636
                    }
                    addPhyFileToRedisComReqDto.setUploadType(queryConfItemMatchAnswerDetailComRespDto.getEndValue());

                    /*D2新增物理文件路径记录到缓存(redis)(公共)[10406]   */
                    Assert.isNull(addPhyFileToRedisComReqDto.getBusinessDataObject(), "D2循环生成资源文件相对路径并缓存相对路径(公共)-D2新增物理文件路径记录到缓存(redis)(公共)-业务数据对象不能为空", false);
                    Assert.isNull(addPhyFileToRedisComReqDto.getUploadType(), "D2循环生成资源文件相对路径并缓存相对路径(公共)-D2新增物理文件路径记录到缓存(redis)(公共)-自定义字段值1不能为空", false);
                    Assert.isNull(addPhyFileToRedisComReqDto.getPyhFilePath(), "D2循环生成资源文件相对路径并缓存相对路径(公共)-D2新增物理文件路径记录到缓存(redis)(公共)-自定义字段值2不能为空", false);
                    addPhyFileToRedisComRespDto = addPhyFileToRedisCom(addPhyFileToRedisComReqDto)/*vcase invoke 同服务,同domain*/;


                }
            } else if ((reqDto != null && reqDto.getPlatformOrTenantDoc() != null && reqDto.getPlatformOrTenantDoc().equals("SPACE"))) {
                //elseif(D2循环生成资源文件相对路径并缓存相对路径(公共).平台或租户文档 等于 租户)  73631

                GenerateSemanticInstanceStoryComRespDto generateSemanticInstanceStoryComRespDto_4 = null;
                if (implementDateFormatComRespDto != null) {
                    GenerateSemanticInstanceStoryComReqDto generateSemanticInstanceStoryComReqDto_2 = new GenerateSemanticInstanceStoryComReqDto();
                    generateSemanticInstanceStoryComReqDto_2.setTemplateSemanticEngineCode("TENANT_DOCUMENT_RELATIVE_PATH");//CUSTOM_CONVENTION//sourceId:2031559_1_73633
                    generateSemanticInstanceStoryComReqDto_2.setFirstFieldName("platformOrTenantDoc");//CUSTOM_CONVENTION//sourceId:2031553_1_73633
                    generateSemanticInstanceStoryComReqDto_2.setSecondFieldName("spaceId");//CUSTOM_CONVENTION//sourceId:2031555_1_73633
                    generateSemanticInstanceStoryComReqDto_2.setThirdFieldName("userId");//CUSTOM_CONVENTION//sourceId:2031557_1_73633
                    generateSemanticInstanceStoryComReqDto_2.setFourFieldName("docUseType");//CUSTOM_CONVENTION//sourceId:2031561_1_73633
                    generateSemanticInstanceStoryComReqDto_2.setFiveFieldName("comTxtField");//CUSTOM_CONVENTION//sourceId:2031563_1_73633
                    if (reqDto != null) {
                        generateSemanticInstanceStoryComReqDto_2.setFirstFieldValue(reqDto.getPlatformOrTenantDoc());//SimpleFieldAssign//sourceId:2031554_1_73633
                        generateSemanticInstanceStoryComReqDto_2.setSecondFieldValue(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:2031556_1_73633
                        generateSemanticInstanceStoryComReqDto_2.setThirdFieldValue(reqDto.getUserId());//SimpleFieldAssign//sourceId:2031558_1_73633
                        generateSemanticInstanceStoryComReqDto_2.setFourFieldValue(reqDto.getDocUseType());//SimpleFieldAssign//sourceId:2031562_1_73633
                    }
                    if (implementDateFormatComRespDto != null) {
                        generateSemanticInstanceStoryComReqDto_2.setFiveFieldValue(implementDateFormatComRespDto.getComTxtField());//SimpleFieldAssign//sourceId:2031564_1_73633
                    }

                    /*D2生成租户文档相对路径[8234]   */
                    Assert.isNull(generateSemanticInstanceStoryComReqDto_2.getTemplateSemanticEngineCode(), "D2循环生成资源文件相对路径并缓存相对路径(公共)-D2生成租户文档相对路径-模板引擎标识不能为空", false);
                    Assert.isNull(generateSemanticInstanceStoryComReqDto_2.getFirstFieldName(), "D2循环生成资源文件相对路径并缓存相对路径(公共)-D2生成租户文档相对路径-第一个字段字段名不能为空", false);
                    Assert.isNull(generateSemanticInstanceStoryComReqDto_2.getFirstFieldValue(), "D2循环生成资源文件相对路径并缓存相对路径(公共)-D2生成租户文档相对路径-第一个字段字段值不能为空", false);
                    Assert.isNull(generateSemanticInstanceStoryComReqDto_2.getSecondFieldName(), "D2循环生成资源文件相对路径并缓存相对路径(公共)-D2生成租户文档相对路径-第二个字段字段名不能为空", false);
                    Assert.isNull(generateSemanticInstanceStoryComReqDto_2.getSecondFieldValue(), "D2循环生成资源文件相对路径并缓存相对路径(公共)-D2生成租户文档相对路径-第二个字段字段值不能为空", false);
                    Assert.isNull(generateSemanticInstanceStoryComReqDto_2.getThirdFieldName(), "D2循环生成资源文件相对路径并缓存相对路径(公共)-D2生成租户文档相对路径-第三个字段字段名不能为空", false);
                    Assert.isNull(generateSemanticInstanceStoryComReqDto_2.getThirdFieldValue(), "D2循环生成资源文件相对路径并缓存相对路径(公共)-D2生成租户文档相对路径-第三个字段字段值不能为空", false);
                    Assert.isNull(generateSemanticInstanceStoryComReqDto_2.getFourFieldName(), "D2循环生成资源文件相对路径并缓存相对路径(公共)-D2生成租户文档相对路径-第四个字段字段名不能为空", false);
                    Assert.isNull(generateSemanticInstanceStoryComReqDto_2.getFourFieldValue(), "D2循环生成资源文件相对路径并缓存相对路径(公共)-D2生成租户文档相对路径-第四个字段字段值不能为空", false);
                    Assert.isNull(generateSemanticInstanceStoryComReqDto_2.getFiveFieldName(), "D2循环生成资源文件相对路径并缓存相对路径(公共)-D2生成租户文档相对路径-第五个字段字段名不能为空", false);
                    Assert.isNull(generateSemanticInstanceStoryComReqDto_2.getFiveFieldValue(), "D2循环生成资源文件相对路径并缓存相对路径(公共)-D2生成租户文档相对路径-第五个字段字段值不能为空", false);
                    generateSemanticInstanceStoryComRespDto_4 = templateEngineService.generateSemanticInstanceStoryCom(generateSemanticInstanceStoryComReqDto_2)/*vcase invoke isSameApp*/;


                }
                GenerateSemanticInstanceStoryComRespDto generateSemanticInstanceStoryComRespDto_6 = null;
                if (generateSemanticInstanceStoryComRespDto_4 != null && implementUploadFileNameToFieldComRespDto != null) {
                    GenerateSemanticInstanceStoryComReqDto generateSemanticInstanceStoryComReqDto_3 = new GenerateSemanticInstanceStoryComReqDto();
                    generateSemanticInstanceStoryComReqDto_3.setTemplateSemanticEngineCode("CONCAT_FILE_PATH");//CUSTOM_CONVENTION//sourceId:2033692_1_73682
                    generateSemanticInstanceStoryComReqDto_3.setFirstFieldName("resourceFileRelaPath");//CUSTOM_CONVENTION//sourceId:2033686_1_73682
                    generateSemanticInstanceStoryComReqDto_3.setSecondFieldName("phyFileUuid");//CUSTOM_CONVENTION//sourceId:2033688_1_73682
                    generateSemanticInstanceStoryComReqDto_3.setThirdFieldName("resourceFileExtension");//CUSTOM_CONVENTION//sourceId:2033690_1_73682
                    if (generateSemanticInstanceStoryComRespDto_4 != null) {
                        generateSemanticInstanceStoryComReqDto_3.setFirstFieldValue(generateSemanticInstanceStoryComRespDto_4.getObjectName());//SimpleFieldAssign//sourceId:2033687_1_73682
                    }
                    if (implementUploadFileNameToFieldComRespDto != null) {
                        generateSemanticInstanceStoryComReqDto_3.setSecondFieldValue(implementUploadFileNameToFieldComRespDto.getPhyFileUuid());//SimpleFieldAssign//sourceId:2033689_1_73682
                        generateSemanticInstanceStoryComReqDto_3.setThirdFieldValue(implementUploadFileNameToFieldComRespDto.getResourceFileExtension());//SimpleFieldAssign//sourceId:2033691_1_73682
                    }

                    /*D2拼接文件路径[8234]   */
                    Assert.isNull(generateSemanticInstanceStoryComReqDto_3.getTemplateSemanticEngineCode(), "D2循环生成资源文件相对路径并缓存相对路径(公共)-D2拼接文件路径-模板引擎标识不能为空", false);
                    Assert.isNull(generateSemanticInstanceStoryComReqDto_3.getFirstFieldName(), "D2循环生成资源文件相对路径并缓存相对路径(公共)-D2拼接文件路径-第一个字段字段名不能为空", false);
                    Assert.isNull(generateSemanticInstanceStoryComReqDto_3.getFirstFieldValue(), "D2循环生成资源文件相对路径并缓存相对路径(公共)-D2拼接文件路径-第一个字段字段值不能为空", false);
                    Assert.isNull(generateSemanticInstanceStoryComReqDto_3.getSecondFieldName(), "D2循环生成资源文件相对路径并缓存相对路径(公共)-D2拼接文件路径-第二个字段字段名不能为空", false);
                    Assert.isNull(generateSemanticInstanceStoryComReqDto_3.getSecondFieldValue(), "D2循环生成资源文件相对路径并缓存相对路径(公共)-D2拼接文件路径-第二个字段字段值不能为空", false);
                    Assert.isNull(generateSemanticInstanceStoryComReqDto_3.getThirdFieldName(), "D2循环生成资源文件相对路径并缓存相对路径(公共)-D2拼接文件路径-第三个字段字段名不能为空", false);
                    Assert.isNull(generateSemanticInstanceStoryComReqDto_3.getThirdFieldValue(), "D2循环生成资源文件相对路径并缓存相对路径(公共)-D2拼接文件路径-第三个字段字段值不能为空", false);
                    generateSemanticInstanceStoryComRespDto_6 = templateEngineService.generateSemanticInstanceStoryCom(generateSemanticInstanceStoryComReqDto_3)/*vcase invoke isSameApp*/;


                }
                AddMemoryBusiness2DataComRespDto addMemoryBusiness2DataComRespDto_1 = null;
                if (generateSemanticInstanceStoryComRespDto_6 != null) {
                    AddMemoryBusiness2DataComReqDto addMemoryBusiness2DataComReqDto_1 = new AddMemoryBusiness2DataComReqDto();
                    addMemoryBusiness2DataComReqDto_1.setIsDataList("TRUE");//sourceId:2033683_1_73680
                    addMemoryBusiness2DataComReqDto_1.setCustomField1("resourceFileRelaPath");//CUSTOM_CONVENTION//sourceId:2033684_1_73680
                    if (reqDto != null) {
                        addMemoryBusiness2DataComReqDto_1.setBusinessDataObject(reqDto.getPlatformOrTenantDoc());//SimpleFieldAssign//sourceId:2033682_1_73680
                        addMemoryBusiness2DataComReqDto_1.setDataObjectBatchCode(reqDto.getDocUseType());//SimpleFieldAssign//sourceId:2033681_1_73680
                    }
                    if (generateSemanticInstanceStoryComRespDto_6 != null) {
                        addMemoryBusiness2DataComReqDto_1.setCustomFieldValue1(generateSemanticInstanceStoryComRespDto_6.getObjectName());//SimpleFieldAssign//sourceId:2033685_1_73680
                    }

                    /*D2新增内存业务数据(业务原子)[9751]   */
                    Assert.isNull(addMemoryBusiness2DataComReqDto_1.getBusinessDataObject(), "D2循环生成资源文件相对路径并缓存相对路径(公共)-D2新增内存业务数据(业务原子)-业务数据对象不能为空", false);
                    Assert.isNull(addMemoryBusiness2DataComReqDto_1.getDataObjectBatchCode(), "D2循环生成资源文件相对路径并缓存相对路径(公共)-D2新增内存业务数据(业务原子)-数据对象批次标识不能为空", false);
                    Assert.isNull(addMemoryBusiness2DataComReqDto_1.getIsDataList(), "D2循环生成资源文件相对路径并缓存相对路径(公共)-D2新增内存业务数据(业务原子)-是否是数据集对象不能为空", false);
                    Assert.isNull(addMemoryBusiness2DataComReqDto_1.getCustomField1(), "D2循环生成资源文件相对路径并缓存相对路径(公共)-D2新增内存业务数据(业务原子)-自定义字段1不能为空", false);
                    Assert.isNull(addMemoryBusiness2DataComReqDto_1.getCustomFieldValue1(), "D2循环生成资源文件相对路径并缓存相对路径(公共)-D2新增内存业务数据(业务原子)-自定义字段值1不能为空", false);
                    addMemoryBusiness2DataComRespDto_1 = businessAtomService.addMemoryBusiness2DataCom(addMemoryBusiness2DataComReqDto_1)/*vcase invoke isSameApp*/;


                }
                AddPhyFileToRedisComRespDto addPhyFileToRedisComRespDto_1 = null;
                if (generateSemanticInstanceStoryComRespDto_4 != null && queryConfItemMatchAnswerDetailComRespDto != null) {
                    AddPhyFileToRedisComReqDto addPhyFileToRedisComReqDto_1 = new AddPhyFileToRedisComReqDto();
                    if (reqDto != null) {
                        addPhyFileToRedisComReqDto_1.setBusinessDataObject(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:2031580_1_73637
                    }
                    if (generateSemanticInstanceStoryComRespDto_4 != null) {
                        addPhyFileToRedisComReqDto_1.setPyhFilePath(generateSemanticInstanceStoryComRespDto_4.getObjectName());//SimpleFieldAssign//sourceId:2031581_1_73637
                    }
                    addPhyFileToRedisComReqDto_1.setUploadType(queryConfItemMatchAnswerDetailComRespDto.getEndValue());

                    /*D2新增物理文件路径记录到缓存(redis)(公共)[10406]   */
                    Assert.isNull(addPhyFileToRedisComReqDto_1.getBusinessDataObject(), "D2循环生成资源文件相对路径并缓存相对路径(公共)-D2新增物理文件路径记录到缓存(redis)(公共)-业务数据对象不能为空", false);
                    Assert.isNull(addPhyFileToRedisComReqDto_1.getPyhFilePath(), "D2循环生成资源文件相对路径并缓存相对路径(公共)-D2新增物理文件路径记录到缓存(redis)(公共)-自定义字段值2不能为空", false);
                    addPhyFileToRedisComRespDto_1 = addPhyFileToRedisCom(addPhyFileToRedisComReqDto_1)/*vcase invoke 同服务,同domain*/;


                }
            }
//virtualUsage M2-执行【循环结束】（特殊方法）  73634
            //ModelCode: circulationEnd
        }

//virtualUsage D2取出文件路径数据集  73697
        QueryMemorysBusinessDataListComRespDto queryMemorysBusinessDataListComRespDto = null;
        QueryMemorysBusinessDataListComReqDto queryMemorysBusinessDataListComReqDto = new QueryMemorysBusinessDataListComReqDto();
        queryMemorysBusinessDataListComReqDto.setCustomField1("resourceFileRelaPath");//CUSTOM_CONVENTION//sourceId:2034071_1_73697
        if (reqDto != null) {
            queryMemorysBusinessDataListComReqDto.setBusinessDataObject(reqDto.getPlatformOrTenantDoc());//SimpleFieldAssign//sourceId:2034060_1_73697
            queryMemorysBusinessDataListComReqDto.setDataObjectBatchCode(reqDto.getDocUseType());//SimpleFieldAssign//sourceId:2034062_1_73697
        }

        /*D2取出文件路径数据集[10425]   */
        Assert.isNull(queryMemorysBusinessDataListComReqDto.getBusinessDataObject(), "D2循环生成资源文件相对路径并缓存相对路径(公共)-D2取出文件路径数据集-业务数据对象不能为空", false);
        Assert.isNull(queryMemorysBusinessDataListComReqDto.getDataObjectBatchCode(), "D2循环生成资源文件相对路径并缓存相对路径(公共)-D2取出文件路径数据集-数据对象批次标识不能为空", false);
        Assert.isNull(queryMemorysBusinessDataListComReqDto.getCustomField1(), "D2循环生成资源文件相对路径并缓存相对路径(公共)-D2取出文件路径数据集-自定义字段1不能为空", false);
        queryMemorysBusinessDataListComRespDto = interfaceModeService.queryMemorysBusinessDataListCom(queryMemorysBusinessDataListComReqDto)/*vcase invoke isSameApp*/;


        queryMemorysBusinessDataListComRespDto_1 = queryMemorysBusinessDataListComRespDto;
        LoopSetResourceFileComRespDto retData = new LoopSetResourceFileComRespDto();
        if (queryMemorysBusinessDataListComRespDto_1 != null && queryMemorysBusinessDataListComRespDto_1.getMemoryBusinessResDataList() != null && !CollectionUtil.isEmpty(queryMemorysBusinessDataListComRespDto_1.getMemoryBusinessResDataList())) {
            retData.setResourceFileList(queryMemorysBusinessDataListComRespDto_1.getMemoryBusinessResDataList().stream().map(item -> item.getCustomField1())
                    .collect(Collectors.toList()));/*list-to-strings*///sourceId:2031570_1
        }


        return retData;
    }

    /**
     * D2执行资源文件上传第三方系统(公共)[10424]
     * gen by moon at 12/12/2024, 4:29:49 PM
     */
    @Trace(operationName = "D2执行资源文件上传第三方系统(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementResourceFileTransSystemComRespDto implementResourceFileTransSystemCom(ImplementResourceFileTransSystemComReqDto reqDto) {


        ImplementResourceFileToThirdPartyRespDto thirtPartFileUploadRes_1 = null;
//步骤0: D2加载资源文件到内存(公共) - downLoadResourceFileCom
        DownLoadResourceFileComRespDto downLoadResourceFileComRespDto = null;
        DownLoadResourceFileComReqDto downLoadResourceFileComReqDto = new DownLoadResourceFileComReqDto();
        if (reqDto != null) {
            downLoadResourceFileComReqDto.setResourceFileRelaPath(reqDto.getResourceFileRelaPath());//SimpleFieldAssign//sourceId:2036659_1
        }

        /*D2加载资源文件到内存(公共)[10440]   */

        downLoadResourceFileComRespDto = downLoadResourceFileCom(downLoadResourceFileComReqDto)/*vcase invoke 同服务,同domain*/;


//步骤1: D2-3查配置项匹配答案详情(公共)（跨服务） - queryConfItemMatchAnswerDetailCom
        QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto = null;
        QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto = new QueryConfItemMatchAnswerDetailComReqDto();
        queryConfItemMatchAnswerDetailComReqDto.setResultAspObjId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:2034959_1
        queryConfItemMatchAnswerDetailComReqDto.setResultAspObjType("TENANT_SPACE");//sourceId:2036657_1
        queryConfItemMatchAnswerDetailComReqDto.setConfItemCode("THIRD_QA_SYSTEM");//CUSTOM_CONVENTION//sourceId:2036656_1
        queryConfItemMatchAnswerDetailComReqDto.setIsPlatData("FALSE");//sourceId:2034961_1

        /*D2查询智能沟通配置[2486]   */
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getResultAspObjId(), "D2执行资源文件上传第三方系统(公共)-D2查询智能沟通配置-开通对象ID不能为空", false);
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getResultAspObjType(), "D2执行资源文件上传第三方系统(公共)-D2查询智能沟通配置-开通对象类型编码不能为空", false);
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getConfItemCode(), "D2执行资源文件上传第三方系统(公共)-D2查询智能沟通配置-配置项标识不能为空", false);
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getIsPlatData(), "D2执行资源文件上传第三方系统(公共)-D2查询智能沟通配置-是否标准答案不能为空", false);
        queryConfItemMatchAnswerDetailComRespDto = confSchemeService.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto)/*vcase invoke isSameApp*/;


//步骤2: M2执行三方文件上传接口（特殊方法） - implementResourceFileToThirdParty
        //ModelCode: thirtPartFileUpload
        ImplementResourceFileToThirdPartyRespDto thirtPartFileUploadRes = null;
        if (queryConfItemMatchAnswerDetailComRespDto != null) {
            ImplementResourceFileToThirdPartyReqDto thirtPartFileUploadReq = new ImplementResourceFileToThirdPartyReqDto();
            if (queryConfItemMatchAnswerDetailComRespDto != null) {
                thirtPartFileUploadReq.setIntelliQaAddress(queryConfItemMatchAnswerDetailComRespDto.getExtensionField1());//SimpleFieldAssign//sourceId:2033863_1
                thirtPartFileUploadReq.setKey(queryConfItemMatchAnswerDetailComRespDto.getExtensionField2());//SimpleFieldAssign//sourceId:2033864_1
            }
            if (reqDto != null) {
                thirtPartFileUploadReq.setResourceFileRelaPath(reqDto.getResourceFileRelaPath());//SimpleFieldAssign//sourceId:2033872_1
            }

            /*M2执行三方文件上传接口（特殊方法）[10421]   */
            Assert.isNull(thirtPartFileUploadReq.getIntelliQaAddress(), "D2执行资源文件上传第三方系统(公共)-M2执行三方文件上传接口（特殊方法）-第三方智能问答地址不能为空", false);
            Assert.isNull(thirtPartFileUploadReq.getKey(), "D2执行资源文件上传第三方系统(公共)-M2执行三方文件上传接口（特殊方法）-key不能为空", false);
            Assert.isNull(thirtPartFileUploadReq.getResourceFileRelaPath(), "D2执行资源文件上传第三方系统(公共)-M2执行三方文件上传接口（特殊方法）-资源文件相对路径不能为空", false);
            thirtPartFileUploadRes = nbResourceFile.implementResourceFileToThirdParty(thirtPartFileUploadReq);


            thirtPartFileUploadRes_1 = thirtPartFileUploadRes;
        }

        ImplementResourceFileTransSystemComRespDto retData = new ImplementResourceFileTransSystemComRespDto();
        if (thirtPartFileUploadRes_1 != null) {
            retData.setThirtPartFileId(thirtPartFileUploadRes_1.getThirtPartFileId());//SimpleFieldAssign//sourceId:2033868_1
        }


        return retData;
    }

    /**
     * D2执行资源文件上链(公共)[10431]
     * gen by moon at 12/8/2024, 11:51:48 PM
     */
    @Trace(operationName = "D2执行资源文件上链(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementEviFileChainComRespDto implementEviFileChainCom(ImplementEviFileChainComReqDto reqDto) {


        ImplementEviFileChainRespDto resourceFileChainRes_1 = null;
//步骤0: M2执行资源文件上链（特殊方法) - implementEviFileChain
        //ModelCode: resourceFileChain
        ImplementEviFileChainRespDto resourceFileChainRes = null;
        ImplementEviFileChainReqDto resourceFileChainReq = new ImplementEviFileChainReqDto();
        if (reqDto != null) {
            resourceFileChainReq.setValidChainCreate(reqDto.getValidChainCreate());//SimpleFieldAssign//sourceId:2034963_1
            resourceFileChainReq.setAppKey(reqDto.getAppKey());//SimpleFieldAssign//sourceId:2034241_1
            resourceFileChainReq.setChainSignature(reqDto.getChainSignature());//SimpleFieldAssign//sourceId:2034243_1
            resourceFileChainReq.setChainTimeMap(reqDto.getChainTimeMap());//SimpleFieldAssign//sourceId:2034240_1
            resourceFileChainReq.setUserName(reqDto.getUserName());//SimpleFieldAssign//sourceId:2034242_1
            resourceFileChainReq.setIdentType(reqDto.getIdentType());//SimpleFieldAssign//sourceId:2034236_1
            resourceFileChainReq.setIdentNo(reqDto.getIdentNo());//SimpleFieldAssign//sourceId:2034237_1
            resourceFileChainReq.setProductId(reqDto.getProductId());//SimpleFieldAssign//sourceId:2034238_1
            resourceFileChainReq.setWorkId(reqDto.getWorkId());//SimpleFieldAssign//sourceId:2034239_1
            resourceFileChainReq.setStepId(reqDto.getStepId());//SimpleFieldAssign//sourceId:2034235_1
        }
        if (reqDto != null && reqDto.getItemList() != null && !CollectionUtil.isEmpty(reqDto.getItemList())) {
            resourceFileChainReq.setItemList(reqDto.getItemList().stream().map(item -> BeanUtil.toBean(item, ItemDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:2034244_1
        }

        /*M2执行资源文件上链（特殊方法)[10428]   */
        Assert.isNull(resourceFileChainReq.getAppKey(), "D2执行资源文件上链(公共)-M2执行资源文件上链（特殊方法)-上链用户Key不能为空", false);
        Assert.isNull(resourceFileChainReq.getChainSignature(), "D2执行资源文件上链(公共)-M2执行资源文件上链（特殊方法)-上链签名不能为空", false);
        Assert.isNull(resourceFileChainReq.getChainTimeMap(), "D2执行资源文件上链(公共)-M2执行资源文件上链（特殊方法)-上链系统时间戳不能为空", false);
        Assert.isNull(resourceFileChainReq.getProductId(), "D2执行资源文件上链(公共)-M2执行资源文件上链（特殊方法)-上链业务ID不能为空", false);
        Assert.isNull(resourceFileChainReq.getWorkId(), "D2执行资源文件上链(公共)-M2执行资源文件上链（特殊方法)-上链事务ID不能为空", false);
        Assert.isNull(resourceFileChainReq.getStepId(), "D2执行资源文件上链(公共)-M2执行资源文件上链（特殊方法)-上链节点ID不能为空", false);
        resourceFileChainRes = nbResourceFile.implementEviFileChain(resourceFileChainReq);


        resourceFileChainRes_1 = resourceFileChainRes;

        ImplementEviFileChainComRespDto retData = new ImplementEviFileChainComRespDto();
        if (resourceFileChainRes_1 != null) {
            retData.setChainAddress(resourceFileChainRes_1.getChainAddress());//SimpleFieldAssign//sourceId:2034259_1
            retData.setHashCal(resourceFileChainRes_1.getHashCal());//SimpleFieldAssign//sourceId:2034260_1
            retData.setDataId(resourceFileChainRes_1.getDataId());//SimpleFieldAssign//sourceId:2034261_1
            retData.setDataHash(resourceFileChainRes_1.getDataHash());//SimpleFieldAssign//sourceId:2034262_1
        }


        return retData;
    }

    /**
     * D2生成上链签名(公共)[10432]
     * gen by moon at 12/8/2024, 3:22:31 AM
     */
    @Trace(operationName = "D2生成上链签名(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ObtainChainTokenComRespDto obtainChainTokenCom(ObtainChainTokenComReqDto reqDto) {


        ObtainChainTokenRespDto obtainChainTokenRes_1 = null;
//步骤0: M2生成上链签名（特殊方法) - obtainChainToken
        //ModelCode: obtainChainToken
        ObtainChainTokenRespDto obtainChainTokenRes = null;
        ObtainChainTokenReqDto obtainChainTokenReq = new ObtainChainTokenReqDto();
        obtainChainTokenReq.setChainCreateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:2034265_1
        if (reqDto != null) {
            obtainChainTokenReq.setAppKey(reqDto.getAppKey());//SimpleFieldAssign//sourceId:2034263_1
            obtainChainTokenReq.setAppSecret(reqDto.getAppSecret());//SimpleFieldAssign//sourceId:2034264_1
        }

        /*M2生成上链签名（特殊方法)[10430]   */
        Assert.isNull(obtainChainTokenReq.getAppKey(), "D2生成上链签名(公共)-M2生成上链签名（特殊方法)-上链用户Key不能为空", false);
        Assert.isNull(obtainChainTokenReq.getAppSecret(), "D2生成上链签名(公共)-M2生成上链签名（特殊方法)-上链用户密钥不能为空", false);
        Assert.isNull(obtainChainTokenReq.getChainCreateTime(), "D2生成上链签名(公共)-M2生成上链签名（特殊方法)-上链系统时间不能为空", false);
        obtainChainTokenRes = nbResourceFile.obtainChainToken(obtainChainTokenReq);


        obtainChainTokenRes_1 = obtainChainTokenRes;

        ObtainChainTokenComRespDto retData = new ObtainChainTokenComRespDto();
        if (obtainChainTokenRes_1 != null) {
            retData.setChainSignature(obtainChainTokenRes_1.getChainSignature());//SimpleFieldAssign//sourceId:2034271_1
            retData.setChainTimeMap(obtainChainTokenRes_1.getChainTimeMap());//SimpleFieldAssign//sourceId:2034272_1
        }


        return retData;
    }

    /**
     * D2执行资源文件上区块链(公共)[10433]
     * gen by moon at 12/8/2024, 11:51:54 PM
     */
    @Trace(operationName = "D2执行资源文件上区块链(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementEviFilesChainComRespDto implementEviFilesChainCom(ImplementEviFilesChainComReqDto reqDto) {


        ImplementEviFileChainComRespDto implementEviFileChainComRespDto_1 = null;
//步骤0: D2-3配置项匹配多选结果转答案(公共) - queryItemMatchMultiSelectResultToAnswerListCom
        QueryItemMatchMultiSelectResultToAnswerListComRespDto queryItemMatchMultiSelectResultToAnswerListComRespDto = null;
        QueryItemMatchMultiSelectResultToAnswerListComReqDto queryItemMatchMultiSelectResultToAnswerListComReqDto = new QueryItemMatchMultiSelectResultToAnswerListComReqDto();
        queryItemMatchMultiSelectResultToAnswerListComReqDto.setResultAspObjId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:2034344_1
        queryItemMatchMultiSelectResultToAnswerListComReqDto.setResultAspObjType("TENANT_SPACE");//sourceId:2034345_1
        queryItemMatchMultiSelectResultToAnswerListComReqDto.setConfItemCode("VALID_CHAIN_URL_ADDRESS");//CUSTOM_CONVENTION//sourceId:2034346_1
        queryItemMatchMultiSelectResultToAnswerListComReqDto.setIsPlatData("FALSE");//sourceId:2034347_1

        /*D2查区块链地址[5196]   */
        Assert.isNull(queryItemMatchMultiSelectResultToAnswerListComReqDto.getResultAspObjId(), "D2执行资源文件上区块链(公共)-D2查区块链地址-开通对象ID不能为空", false);
        Assert.isNull(queryItemMatchMultiSelectResultToAnswerListComReqDto.getResultAspObjType(), "D2执行资源文件上区块链(公共)-D2查区块链地址-开通对象类型编码不能为空", false);
        Assert.isNull(queryItemMatchMultiSelectResultToAnswerListComReqDto.getConfItemCode(), "D2执行资源文件上区块链(公共)-D2查区块链地址-配置项标识不能为空", false);
        Assert.isNull(queryItemMatchMultiSelectResultToAnswerListComReqDto.getIsPlatData(), "D2执行资源文件上区块链(公共)-D2查区块链地址-是否标准答案不能为空", false);
        queryItemMatchMultiSelectResultToAnswerListComRespDto = confSchemeService.queryItemMatchMultiSelectResultToAnswerListCom(queryItemMatchMultiSelectResultToAnswerListComReqDto)/*vcase invoke isSameApp*/;


//步骤1: D2-3配置项匹配多选结果转答案(公共) - queryItemMatchMultiSelectResultToAnswerListCom
        QueryItemMatchMultiSelectResultToAnswerListComRespDto queryItemMatchMultiSelectResultToAnswerListComRespDto_2 = null;
        QueryItemMatchMultiSelectResultToAnswerListComReqDto queryItemMatchMultiSelectResultToAnswerListComReqDto_1 = new QueryItemMatchMultiSelectResultToAnswerListComReqDto();
        queryItemMatchMultiSelectResultToAnswerListComReqDto_1.setResultAspObjId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:2034383_1
        queryItemMatchMultiSelectResultToAnswerListComReqDto_1.setResultAspObjType("TENANT_SPACE");//sourceId:2034384_1
        queryItemMatchMultiSelectResultToAnswerListComReqDto_1.setConfItemCode("VALID_CHAIN_USER_INFO");//CUSTOM_CONVENTION//sourceId:2034385_1
        queryItemMatchMultiSelectResultToAnswerListComReqDto_1.setIsPlatData("FALSE");//sourceId:2034386_1

        /*D2查区块链用户信息[5196]   */
        Assert.isNull(queryItemMatchMultiSelectResultToAnswerListComReqDto_1.getResultAspObjId(), "D2执行资源文件上区块链(公共)-D2查区块链用户信息-开通对象ID不能为空", false);
        Assert.isNull(queryItemMatchMultiSelectResultToAnswerListComReqDto_1.getResultAspObjType(), "D2执行资源文件上区块链(公共)-D2查区块链用户信息-开通对象类型编码不能为空", false);
        Assert.isNull(queryItemMatchMultiSelectResultToAnswerListComReqDto_1.getConfItemCode(), "D2执行资源文件上区块链(公共)-D2查区块链用户信息-配置项标识不能为空", false);
        Assert.isNull(queryItemMatchMultiSelectResultToAnswerListComReqDto_1.getIsPlatData(), "D2执行资源文件上区块链(公共)-D2查区块链用户信息-是否标准答案不能为空", false);
        queryItemMatchMultiSelectResultToAnswerListComRespDto_2 = confSchemeService.queryItemMatchMultiSelectResultToAnswerListCom(queryItemMatchMultiSelectResultToAnswerListComReqDto_1)/*vcase invoke isSameApp*/;


//步骤2: D2-3配置项匹配多选结果转答案(公共) - queryItemMatchMultiSelectResultToAnswerListCom
        QueryItemMatchMultiSelectResultToAnswerListComRespDto queryItemMatchMultiSelectResultToAnswerListComRespDto_4 = null;
        QueryItemMatchMultiSelectResultToAnswerListComReqDto queryItemMatchMultiSelectResultToAnswerListComReqDto_2 = new QueryItemMatchMultiSelectResultToAnswerListComReqDto();
        queryItemMatchMultiSelectResultToAnswerListComReqDto_2.setResultAspObjId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:2034422_1
        queryItemMatchMultiSelectResultToAnswerListComReqDto_2.setResultAspObjType("TENANT_SPACE");//sourceId:2034423_1
        queryItemMatchMultiSelectResultToAnswerListComReqDto_2.setConfItemCode("VALID_CHAIN_INFO");//CUSTOM_CONVENTION//sourceId:2034424_1
        queryItemMatchMultiSelectResultToAnswerListComReqDto_2.setIsPlatData("FALSE");//sourceId:2034425_1

        /*D2查区块链上链信息[5196]   */
        Assert.isNull(queryItemMatchMultiSelectResultToAnswerListComReqDto_2.getResultAspObjId(), "D2执行资源文件上区块链(公共)-D2查区块链上链信息-开通对象ID不能为空", false);
        Assert.isNull(queryItemMatchMultiSelectResultToAnswerListComReqDto_2.getResultAspObjType(), "D2执行资源文件上区块链(公共)-D2查区块链上链信息-开通对象类型编码不能为空", false);
        Assert.isNull(queryItemMatchMultiSelectResultToAnswerListComReqDto_2.getConfItemCode(), "D2执行资源文件上区块链(公共)-D2查区块链上链信息-配置项标识不能为空", false);
        Assert.isNull(queryItemMatchMultiSelectResultToAnswerListComReqDto_2.getIsPlatData(), "D2执行资源文件上区块链(公共)-D2查区块链上链信息-是否标准答案不能为空", false);
        queryItemMatchMultiSelectResultToAnswerListComRespDto_4 = confSchemeService.queryItemMatchMultiSelectResultToAnswerListCom(queryItemMatchMultiSelectResultToAnswerListComReqDto_2)/*vcase invoke isSameApp*/;


//步骤3: D2生成上链签名(公共) - obtainChainTokenCom
        ObtainChainTokenComRespDto obtainChainTokenComRespDto = null;
        if (queryItemMatchMultiSelectResultToAnswerListComRespDto_2 != null) {
            ObtainChainTokenComReqDto obtainChainTokenComReqDto = new ObtainChainTokenComReqDto();
            if (queryItemMatchMultiSelectResultToAnswerListComRespDto_2 != null) {
                obtainChainTokenComReqDto.setAppKey(queryItemMatchMultiSelectResultToAnswerListComRespDto_2.getAppKey());//SimpleFieldAssign//sourceId:2034308_1
                obtainChainTokenComReqDto.setAppSecret(queryItemMatchMultiSelectResultToAnswerListComRespDto_2.getAppSecret());//SimpleFieldAssign//sourceId:2034309_1
            }

            /*D2生成上链签名(公共)[10432]   */
            Assert.isNull(obtainChainTokenComReqDto.getAppKey(), "D2执行资源文件上区块链(公共)-D2生成上链签名(公共)-上链用户Key不能为空", false);
            Assert.isNull(obtainChainTokenComReqDto.getAppSecret(), "D2执行资源文件上区块链(公共)-D2生成上链签名(公共)-上链用户密钥不能为空", false);
            obtainChainTokenComRespDto = obtainChainTokenCom(obtainChainTokenComReqDto)/*vcase invoke 同服务,同domain*/;


        }

//步骤4: D2执行资源文件上链(公共) - implementEviFileChainCom
        ImplementEviFileChainComRespDto implementEviFileChainComRespDto = null;
        if (queryItemMatchMultiSelectResultToAnswerListComRespDto != null) {
            ImplementEviFileChainComReqDto implementEviFileChainComReqDto = new ImplementEviFileChainComReqDto();
            if (queryItemMatchMultiSelectResultToAnswerListComRespDto != null) {
                implementEviFileChainComReqDto.setValidChainCreate(queryItemMatchMultiSelectResultToAnswerListComRespDto.getValidChainCreate());//SimpleFieldAssign//sourceId:2034965_1
            }
            if (queryItemMatchMultiSelectResultToAnswerListComRespDto_2 != null) {
                implementEviFileChainComReqDto.setAppKey(queryItemMatchMultiSelectResultToAnswerListComRespDto_2.getAppKey());//SimpleFieldAssign//sourceId:2034294_1
            }
            if (obtainChainTokenComRespDto != null) {
                implementEviFileChainComReqDto.setChainSignature(obtainChainTokenComRespDto.getChainSignature());//SimpleFieldAssign//sourceId:2034295_1
                implementEviFileChainComReqDto.setChainTimeMap(obtainChainTokenComRespDto.getChainTimeMap());//SimpleFieldAssign//sourceId:2034296_1
            }
            if (reqDto != null && reqDto.getItemList() != null && !CollectionUtil.isEmpty(reqDto.getItemList())) {
                implementEviFileChainComReqDto.setItemList(reqDto.getItemList().stream().map(item -> BeanUtil.toBean(item, ItemDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:2034303_1
            }
            if (reqDto != null) {
                implementEviFileChainComReqDto.setUserName(reqDto.getUserName());//SimpleFieldAssign//sourceId:2034297_1
                implementEviFileChainComReqDto.setIdentType(reqDto.getIdentType());//SimpleFieldAssign//sourceId:2034298_1
                implementEviFileChainComReqDto.setIdentNo(reqDto.getIdentNo());//SimpleFieldAssign//sourceId:2034299_1
            }
            if (queryItemMatchMultiSelectResultToAnswerListComRespDto_4 != null) {
                implementEviFileChainComReqDto.setProductId(queryItemMatchMultiSelectResultToAnswerListComRespDto_4.getProductId());//SimpleFieldAssign//sourceId:2034300_1
                implementEviFileChainComReqDto.setStepId(queryItemMatchMultiSelectResultToAnswerListComRespDto_4.getStepId());//SimpleFieldAssign//sourceId:2034302_1
                implementEviFileChainComReqDto.setWorkId(queryItemMatchMultiSelectResultToAnswerListComRespDto_4.getWorkId());//SimpleFieldAssign//sourceId:2034301_1
            }

            /*D2执行资源文件上链(公共)[10431]   */
            Assert.isNull(implementEviFileChainComReqDto.getAppKey(), "D2执行资源文件上区块链(公共)-D2执行资源文件上链(公共)-上链用户Key不能为空", false);
            Assert.isNull(implementEviFileChainComReqDto.getChainSignature(), "D2执行资源文件上区块链(公共)-D2执行资源文件上链(公共)-上链签名不能为空", false);
            Assert.isNull(implementEviFileChainComReqDto.getChainTimeMap(), "D2执行资源文件上区块链(公共)-D2执行资源文件上链(公共)-上链系统时间戳不能为空", false);
            Assert.isNull(implementEviFileChainComReqDto.getProductId(), "D2执行资源文件上区块链(公共)-D2执行资源文件上链(公共)-上链业务ID不能为空", false);
            Assert.isNull(implementEviFileChainComReqDto.getStepId(), "D2执行资源文件上区块链(公共)-D2执行资源文件上链(公共)-上链节点ID不能为空", false);
            Assert.isNull(implementEviFileChainComReqDto.getWorkId(), "D2执行资源文件上区块链(公共)-D2执行资源文件上链(公共)-上链事务ID不能为空", false);
            implementEviFileChainComRespDto = implementEviFileChainCom(implementEviFileChainComReqDto)/*vcase invoke 同服务,同domain*/;


            implementEviFileChainComRespDto_1 = implementEviFileChainComRespDto;
        }

        ImplementEviFilesChainComRespDto retData = new ImplementEviFilesChainComRespDto();
        if (implementEviFileChainComRespDto_1 != null) {
            retData.setChainAddress(implementEviFileChainComRespDto_1.getChainAddress());//SimpleFieldAssign//sourceId:2034966_1
            retData.setHashCal(implementEviFileChainComRespDto_1.getHashCal());//SimpleFieldAssign//sourceId:2034967_1
            retData.setDataId(implementEviFileChainComRespDto_1.getDataId());//SimpleFieldAssign//sourceId:2034788_1
            retData.setDataHash(implementEviFileChainComRespDto_1.getDataHash());//SimpleFieldAssign//sourceId:2034789_1
        }


        return retData;
    }

    /**
     * D2生成资源文件问答内容(公共)[10426]
     * gen by moon at 12/12/2024, 4:29:48 PM
     */
    @Trace(operationName = "D2生成资源文件问答内容(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public GenerateResourceFileQuestionContentComRespDto generateResourceFileQuestionContentCom(GenerateResourceFileQuestionContentComReqDto reqDto) {


        AddObjectStorageConfigRespDto receptionServiceRes_1 = null;
        GenerateSemanticInstanceStoryComRespDto generateSemanticInstanceStoryComRespDto_6 = null;
        if ((reqDto != null && reqDto.getFileQaModel() != null && reqDto.getFileQaModel().equals("SINGLE_LONG_TEXT_Q_MODEL"))) {
            //if(D2生成资源文件问答内容(公共).文件问答模式 等于 单个长文本提问模式)  73702

            GenerateSemanticInstanceStoryComRespDto generateSemanticInstanceStoryComRespDto = null;
            GenerateSemanticInstanceStoryComReqDto generateSemanticInstanceStoryComReqDto = new GenerateSemanticInstanceStoryComReqDto();
            generateSemanticInstanceStoryComReqDto.setTemplateSemanticEngineCode("SINGLE_LONG_TEXT_QUESTION");//CUSTOM_CONVENTION//sourceId:2034150_1_73705
            generateSemanticInstanceStoryComReqDto.setFirstFieldName("thirtPartFileId");//CUSTOM_CONVENTION//sourceId:2034151_1_73705
            if (reqDto != null) {
                generateSemanticInstanceStoryComReqDto.setFirstFieldValue(reqDto.getThirtPartFileId());//SimpleFieldAssign//sourceId:2034152_1_73705
            }

            /*D2生成单个长文本提问命令[8234]   */
            Assert.isNull(generateSemanticInstanceStoryComReqDto.getTemplateSemanticEngineCode(), "D2生成资源文件问答内容(公共)-D2生成单个长文本提问命令-模板引擎标识不能为空", false);
            Assert.isNull(generateSemanticInstanceStoryComReqDto.getFirstFieldName(), "D2生成资源文件问答内容(公共)-D2生成单个长文本提问命令-第一个字段字段名不能为空", false);
            Assert.isNull(generateSemanticInstanceStoryComReqDto.getFirstFieldValue(), "D2生成资源文件问答内容(公共)-D2生成单个长文本提问命令-第一个字段字段值不能为空", false);
            generateSemanticInstanceStoryComRespDto = templateEngineService.generateSemanticInstanceStoryCom(generateSemanticInstanceStoryComReqDto)/*vcase invoke isSameApp*/;


//ModelCode: receptionService
            AddObjectStorageConfigRespDto receptionServiceRes = null;
            if (generateSemanticInstanceStoryComRespDto != null) {
                AddObjectStorageConfigReqDto receptionServiceReq = new AddObjectStorageConfigReqDto();
                if (generateSemanticInstanceStoryComRespDto != null) {
                    receptionServiceReq.setCustomField(generateSemanticInstanceStoryComRespDto.getObjectName());//SimpleFieldAssign//sourceId:2035000_1_73710
                }

                /*接收问答命令出参[10411]  用于特殊方法接收上游入参。 */
                Assert.isNull(receptionServiceReq.getCustomField(), "D2生成资源文件问答内容(公共)-接收问答命令出参-自定义字段不能为空", false);
                receptionServiceRes = nbResourceFile.addObjectStorageConfig(receptionServiceReq);


                receptionServiceRes_1 = receptionServiceRes;
            }
        } else if ((reqDto != null && reqDto.getFileQaModel() != null && reqDto.getFileQaModel().equals("SINGLE_LONG_TEXT_AQ_MODEL"))) {
            //elseif(D2生成资源文件问答内容(公共).文件问答模式 等于 单个长文本追问模式)  73703

            GenerateSemanticInstanceStoryComRespDto generateSemanticInstanceStoryComRespDto_2 = null;
            GenerateSemanticInstanceStoryComReqDto generateSemanticInstanceStoryComReqDto_1 = new GenerateSemanticInstanceStoryComReqDto();


            /*D2生成多个长文本提问命令[8234]   */
            Assert.isNull(generateSemanticInstanceStoryComReqDto_1.getTemplateSemanticEngineCode(), "D2生成资源文件问答内容(公共)-D2生成多个长文本提问命令-模板引擎标识不能为空", false);
            generateSemanticInstanceStoryComRespDto_2 = templateEngineService.generateSemanticInstanceStoryCom(generateSemanticInstanceStoryComReqDto_1)/*vcase invoke isSameApp*/;


//ModelCode: receptionService
            AddObjectStorageConfigRespDto receptionServiceRes_2 = null;
            if (generateSemanticInstanceStoryComRespDto_2 != null) {
                AddObjectStorageConfigReqDto receptionServiceReq_1 = new AddObjectStorageConfigReqDto();
                if (generateSemanticInstanceStoryComRespDto_2 != null) {
                    receptionServiceReq_1.setCustomField(generateSemanticInstanceStoryComRespDto_2.getObjectName());//SimpleFieldAssign//sourceId:2035000_1_73711
                }

                /*接收问答命令出参[10411]  用于特殊方法接收上游入参。 */
                Assert.isNull(receptionServiceReq_1.getCustomField(), "D2生成资源文件问答内容(公共)-接收问答命令出参-自定义字段不能为空", false);
                receptionServiceRes_2 = nbResourceFile.addObjectStorageConfig(receptionServiceReq_1);


                receptionServiceRes_1 = receptionServiceRes_2;
            }
        } else if ((reqDto != null && reqDto.getFileQaModel() != null && reqDto.getFileQaModel().equals("MUTI_LONG_TEXT_Q_MODEL"))) {
            //elseif(D2生成资源文件问答内容(公共).文件问答模式 等于 多个文本提问模式)  73704

            GenerateSemanticInstanceStoryComRespDto generateSemanticInstanceStoryComRespDto_4 = null;
            GenerateSemanticInstanceStoryComReqDto generateSemanticInstanceStoryComReqDto_2 = new GenerateSemanticInstanceStoryComReqDto();


            /*D2生成多个长文本提问命令[8234]   */
            Assert.isNull(generateSemanticInstanceStoryComReqDto_2.getTemplateSemanticEngineCode(), "D2生成资源文件问答内容(公共)-D2生成多个长文本提问命令-模板引擎标识不能为空", false);
            generateSemanticInstanceStoryComRespDto_4 = templateEngineService.generateSemanticInstanceStoryCom(generateSemanticInstanceStoryComReqDto_2)/*vcase invoke isSameApp*/;


//ModelCode: receptionService
            AddObjectStorageConfigRespDto receptionServiceRes_3 = null;
            if (generateSemanticInstanceStoryComRespDto_4 != null) {
                AddObjectStorageConfigReqDto receptionServiceReq_2 = new AddObjectStorageConfigReqDto();
                if (generateSemanticInstanceStoryComRespDto_4 != null) {
                    receptionServiceReq_2.setCustomField(generateSemanticInstanceStoryComRespDto_4.getObjectName());//SimpleFieldAssign//sourceId:2035000_1_73712
                }

                /*接收问答命令出参[10411]  用于特殊方法接收上游入参。 */
                Assert.isNull(receptionServiceReq_2.getCustomField(), "D2生成资源文件问答内容(公共)-接收问答命令出参-自定义字段不能为空", false);
                receptionServiceRes_3 = nbResourceFile.addObjectStorageConfig(receptionServiceReq_2);


                receptionServiceRes_1 = receptionServiceRes_3;
            }
        }
//virtualUsage D2生成文件问答询问内容  73720
        GenerateSemanticInstanceStoryComRespDto generateSemanticInstanceStoryComRespDto_5 = null;
        GenerateSemanticInstanceStoryComReqDto generateSemanticInstanceStoryComReqDto_3 = new GenerateSemanticInstanceStoryComReqDto();


        /*D2生成文件问答询问内容[8234]   */
        Assert.isNull(generateSemanticInstanceStoryComReqDto_3.getTemplateSemanticEngineCode(), "D2生成资源文件问答内容(公共)-D2生成文件问答询问内容-模板引擎标识不能为空", false);
        generateSemanticInstanceStoryComRespDto_5 = templateEngineService.generateSemanticInstanceStoryCom(generateSemanticInstanceStoryComReqDto_3)/*vcase invoke isSameApp*/;


        generateSemanticInstanceStoryComRespDto_6 = generateSemanticInstanceStoryComRespDto_5;
        GenerateResourceFileQuestionContentComRespDto retData = new GenerateResourceFileQuestionContentComRespDto();
        if (receptionServiceRes_1 != null) {
            retData.setCustomField(receptionServiceRes_1.getCustomField());//SimpleFieldAssign//sourceId:2035317_1
        }
        if (generateSemanticInstanceStoryComRespDto_6 != null) {
            retData.setObjectName(generateSemanticInstanceStoryComRespDto_6.getObjectName());//SimpleFieldAssign//sourceId:2035648_1
        }


        return retData;
    }

    /**
     * D2加载资源文件到内存(公共)[10440]
     * gen by moon at 12/15/2024, 5:26:53 PM
     */
    @Trace(operationName = "D2加载资源文件到内存(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public DownLoadResourceFileComRespDto downLoadResourceFileCom(DownLoadResourceFileComReqDto reqDto) {


        //virtualUsage D2查询上传配置信息详情(公共)  73713
        QueryUploadConfigInfoDetailComRespDto queryUploadConfigInfoDetailComRespDto = null;
        QueryUploadConfigInfoDetailComReqDto queryUploadConfigInfoDetailComReqDto = new QueryUploadConfigInfoDetailComReqDto();


        /*D2查询上传配置信息详情(公共)[10408]   */

        queryUploadConfigInfoDetailComRespDto = netDiskService.queryUploadConfigInfoDetailCom(queryUploadConfigInfoDetailComReqDto)/*vcase invoke isSameApp*/;


        if ((queryUploadConfigInfoDetailComRespDto != null && queryUploadConfigInfoDetailComRespDto.getAliyunOssServiceAddress() != null)) {
            //if(D2查询上传配置信息详情(公共).阿里云OSS服务地址 值不等于空 )  73714

            LoadAliYunFileComRespDto loadAliYunFileComRespDto = null;
            if (queryUploadConfigInfoDetailComRespDto != null) {
                LoadAliYunFileComReqDto loadAliYunFileComReqDto = new LoadAliYunFileComReqDto();
                if (queryUploadConfigInfoDetailComRespDto != null) {
                    loadAliYunFileComReqDto.setAliyunOssServiceAddress(queryUploadConfigInfoDetailComRespDto.getAliyunOssDisplayRootPath());//SimpleFieldAssign//sourceId:2035062_1_73717
                    loadAliYunFileComReqDto.setAliyunOssKey(queryUploadConfigInfoDetailComRespDto.getAliyunOssKey());//SimpleFieldAssign//sourceId:2035063_1_73717
                    loadAliYunFileComReqDto.setAliyunOssSecretKey(queryUploadConfigInfoDetailComRespDto.getAliyunOssSecretKey());//SimpleFieldAssign//sourceId:2035064_1_73717
                    loadAliYunFileComReqDto.setAliyunOssBucketName(queryUploadConfigInfoDetailComRespDto.getAliyunOssBucketName());//SimpleFieldAssign//sourceId:2035065_1_73717
                }
                if (reqDto != null) {
                    loadAliYunFileComReqDto.setFile(reqDto.getResourceFileRelaPath());//SimpleFieldAssign//sourceId:2035066_1_73717
                }

                /*D2获取阿里云文件(公共)[10445]   */
                Assert.isNull(loadAliYunFileComReqDto.getAliyunOssServiceAddress(), "D2加载资源文件到内存(公共)-D2获取阿里云文件(公共)-阿里云OSS服务地址不能为空", false);
                Assert.isNull(loadAliYunFileComReqDto.getAliyunOssKey(), "D2加载资源文件到内存(公共)-D2获取阿里云文件(公共)-阿里云OSS的钥匙不能为空", false);
                Assert.isNull(loadAliYunFileComReqDto.getAliyunOssSecretKey(), "D2加载资源文件到内存(公共)-D2获取阿里云文件(公共)-阿里云OSS的密钥不能为空", false);
                Assert.isNull(loadAliYunFileComReqDto.getAliyunOssBucketName(), "D2加载资源文件到内存(公共)-D2获取阿里云文件(公共)-阿里云OSS桶名字不能为空", false);
                Assert.isNull(loadAliYunFileComReqDto.getFile(), "D2加载资源文件到内存(公共)-D2获取阿里云文件(公共)-文件不能为空", false);
                loadAliYunFileComRespDto = loadAliYunFileCom(loadAliYunFileComReqDto)/*vcase invoke 同服务,同domain*/;


            }
        } else if ((queryUploadConfigInfoDetailComRespDto != null && queryUploadConfigInfoDetailComRespDto.getMinioServiceAddress() != null)) {
            //elseif(D2查询上传配置信息详情(公共).MINIO服务地址 值不等于空 )  73715

            LoadMinioFileComRespDto loadMinioFileComRespDto = null;
            if (queryUploadConfigInfoDetailComRespDto != null) {
                LoadMinioFileComReqDto loadMinioFileComReqDto = new LoadMinioFileComReqDto();
                if (queryUploadConfigInfoDetailComRespDto != null) {
                    loadMinioFileComReqDto.setMinioServiceAddress(queryUploadConfigInfoDetailComRespDto.getMinioServiceAddress());//SimpleFieldAssign//sourceId:2035067_1_73718
                    loadMinioFileComReqDto.setMinioKey(queryUploadConfigInfoDetailComRespDto.getMinioKey());//SimpleFieldAssign//sourceId:2035068_1_73718
                    loadMinioFileComReqDto.setMinioSecretKey(queryUploadConfigInfoDetailComRespDto.getMinioSecretKey());//SimpleFieldAssign//sourceId:2035069_1_73718
                    loadMinioFileComReqDto.setMinioBucketName(queryUploadConfigInfoDetailComRespDto.getMinioBucketName());//SimpleFieldAssign//sourceId:2035070_1_73718
                }
                if (reqDto != null) {
                    loadMinioFileComReqDto.setFile(reqDto.getResourceFileRelaPath());//SimpleFieldAssign//sourceId:2035071_1_73718
                }

                /*D2获取minio文件(公共)[10446]   */
                Assert.isNull(loadMinioFileComReqDto.getMinioServiceAddress(), "D2加载资源文件到内存(公共)-D2获取minio文件(公共)-MINIO服务地址不能为空", false);
                Assert.isNull(loadMinioFileComReqDto.getMinioKey(), "D2加载资源文件到内存(公共)-D2获取minio文件(公共)-MINIO的钥匙不能为空", false);
                Assert.isNull(loadMinioFileComReqDto.getMinioSecretKey(), "D2加载资源文件到内存(公共)-D2获取minio文件(公共)-MINIO的密钥不能为空", false);
                Assert.isNull(loadMinioFileComReqDto.getMinioBucketName(), "D2加载资源文件到内存(公共)-D2获取minio文件(公共)-MINIO桶名字不能为空", false);
                Assert.isNull(loadMinioFileComReqDto.getFile(), "D2加载资源文件到内存(公共)-D2获取minio文件(公共)-文件不能为空", false);
                loadMinioFileComRespDto = loadMinioFileCom(loadMinioFileComReqDto)/*vcase invoke 同服务,同domain*/;


            }
        } else if ((queryUploadConfigInfoDetailComRespDto != null && queryUploadConfigInfoDetailComRespDto.getLocalStorageRootPath() != null)) {
            //elseif(D2查询上传配置信息详情(公共).本地存储根路径 值不等于空 )  73716

            LoadLocalFileComRespDto loadLocalFileComRespDto = null;
            if (queryUploadConfigInfoDetailComRespDto != null) {
                LoadLocalFileComReqDto loadLocalFileComReqDto = new LoadLocalFileComReqDto();
                if (queryUploadConfigInfoDetailComRespDto != null) {
                    loadLocalFileComReqDto.setLocalStorageRootPath(queryUploadConfigInfoDetailComRespDto.getLocalStorageRootPath());//SimpleFieldAssign//sourceId:2037010_1_73719
                }
                if (reqDto != null) {
                    loadLocalFileComReqDto.setFile(reqDto.getResourceFileRelaPath());//SimpleFieldAssign//sourceId:2035072_1_73719
                }

                /*D2获取本地文件(公共)[10447]   */
                Assert.isNull(loadLocalFileComReqDto.getLocalStorageRootPath(), "D2加载资源文件到内存(公共)-D2获取本地文件(公共)-本地存储根路径不能为空", false);
                Assert.isNull(loadLocalFileComReqDto.getFile(), "D2加载资源文件到内存(公共)-D2获取本地文件(公共)-文件不能为空", false);
                loadLocalFileComRespDto = loadLocalFileCom(loadLocalFileComReqDto)/*vcase invoke 同服务,同domain*/;


            }
        }
        DownLoadResourceFileComRespDto retData = new DownLoadResourceFileComRespDto();


        return retData;
    }

    /**
     * D2组装资源文件提问列表[10441]
     * gen by moon at 12/11/2024, 11:56:43 AM
     */
    @Trace(operationName = "D2组装资源文件提问列表")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public AssembleFileQListComRespDto assembleFileQListCom(AssembleFileQListComReqDto reqDto) {


        QueryMemorysBusinessDataListComRespDto queryMemorysBusinessDataListComRespDto_1 = null;
//步骤0: M2执行智能沟通接收入参 - implementSmartSessionReceiveFieldInput
        //ModelCode: receptionService
        ImplementSmartSessionReceiveFieldInputRespDto receptionServiceRes = null;
        ImplementSmartSessionReceiveFieldInputReqDto receptionServiceReq = new ImplementSmartSessionReceiveFieldInputReqDto();
        if (reqDto != null) {
            receptionServiceReq.setContent(reqDto.getContent());//SimpleFieldAssign//sourceId:2035620_1
            receptionServiceReq.setCustomField1(reqDto.getCustomField1());//SimpleFieldAssign//sourceId:2035649_1
        }

        /*M2执行智能沟通接收入参[8109]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getContent(), "D2组装资源文件提问列表-M2执行智能沟通接收入参-消息内容不能为空", false);
        receptionServiceRes = nbResourceFile.implementSmartSessionReceiveFieldInput(receptionServiceReq);


//步骤1: D2构造智能问答列表单条内容(公共) - addGuidedThirdPartyIntelligentQaCom
        AddGuidedThirdPartyIntelligentQaComRespDto addGuidedThirdPartyIntelligentQaComRespDto = null;
        AddGuidedThirdPartyIntelligentQaComReqDto addGuidedThirdPartyIntelligentQaComReqDto = new AddGuidedThirdPartyIntelligentQaComReqDto();
        addGuidedThirdPartyIntelligentQaComReqDto.setCustomFieldValue1("user");//CUSTOM_CONVENTION//sourceId:2035624_1
        if (reqDto != null) {
            addGuidedThirdPartyIntelligentQaComReqDto.setBusinessDataObject(reqDto.getContent());//SimpleFieldAssign//sourceId:2035623_1
            addGuidedThirdPartyIntelligentQaComReqDto.setCustomFieldValue2(reqDto.getContent());//SimpleFieldAssign//sourceId:2035625_1
        }

        /*D2构造智能问答列表单条内容(公共)[10448]   */
        Assert.isNull(addGuidedThirdPartyIntelligentQaComReqDto.getBusinessDataObject(), "D2组装资源文件提问列表-D2构造智能问答列表单条内容(公共)-业务数据对象不能为空", false);
        Assert.isNull(addGuidedThirdPartyIntelligentQaComReqDto.getCustomFieldValue1(), "D2组装资源文件提问列表-D2构造智能问答列表单条内容(公共)-自定义字段值1不能为空", false);
        Assert.isNull(addGuidedThirdPartyIntelligentQaComReqDto.getCustomFieldValue2(), "D2组装资源文件提问列表-D2构造智能问答列表单条内容(公共)-自定义字段值2不能为空", false);
        addGuidedThirdPartyIntelligentQaComRespDto = intelligentCommunicationService.addGuidedThirdPartyIntelligentQaCom(addGuidedThirdPartyIntelligentQaComReqDto)/*vcase invoke isSameApp*/;


//步骤2: D2构造智能问答列表单条内容(公共) - addGuidedThirdPartyIntelligentQaCom
        AddGuidedThirdPartyIntelligentQaComRespDto addGuidedThirdPartyIntelligentQaComRespDto_1 = null;
        AddGuidedThirdPartyIntelligentQaComReqDto addGuidedThirdPartyIntelligentQaComReqDto_1 = new AddGuidedThirdPartyIntelligentQaComReqDto();
        addGuidedThirdPartyIntelligentQaComReqDto_1.setCustomFieldValue1("system");//CUSTOM_CONVENTION//sourceId:2035627_1
        if (reqDto != null) {
            addGuidedThirdPartyIntelligentQaComReqDto_1.setBusinessDataObject(reqDto.getContent());//SimpleFieldAssign//sourceId:2035626_1
            addGuidedThirdPartyIntelligentQaComReqDto_1.setCustomFieldValue2(reqDto.getCustomField1());//SimpleFieldAssign//sourceId:2035628_1
        }

        /*D2构造智能问答列表单条内容(公共)[10448]   */
        Assert.isNull(addGuidedThirdPartyIntelligentQaComReqDto_1.getBusinessDataObject(), "D2组装资源文件提问列表-D2构造智能问答列表单条内容(公共)-业务数据对象不能为空", false);
        Assert.isNull(addGuidedThirdPartyIntelligentQaComReqDto_1.getCustomFieldValue1(), "D2组装资源文件提问列表-D2构造智能问答列表单条内容(公共)-自定义字段值1不能为空", false);
        Assert.isNull(addGuidedThirdPartyIntelligentQaComReqDto_1.getCustomFieldValue2(), "D2组装资源文件提问列表-D2构造智能问答列表单条内容(公共)-自定义字段值2不能为空", false);
        addGuidedThirdPartyIntelligentQaComRespDto_1 = intelligentCommunicationService.addGuidedThirdPartyIntelligentQaCom(addGuidedThirdPartyIntelligentQaComReqDto_1)/*vcase invoke isSameApp*/;


//步骤3: D2查询内存业务数据列表(业务原子) - queryMemorysBusinessDataListCom
        QueryMemorysBusinessDataListComRespDto queryMemorysBusinessDataListComRespDto = null;
        QueryMemorysBusinessDataListComReqDto queryMemorysBusinessDataListComReqDto = new QueryMemorysBusinessDataListComReqDto();
        queryMemorysBusinessDataListComReqDto.setDataObjectBatchCode(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:2035654_1
        queryMemorysBusinessDataListComReqDto.setCustomField1("role");//CUSTOM_CONVENTION//sourceId:2035653_1
        queryMemorysBusinessDataListComReqDto.setCustomField2("content");//CUSTOM_CONVENTION//sourceId:2035655_1
        if (reqDto != null) {
            queryMemorysBusinessDataListComReqDto.setBusinessDataObject(reqDto.getContent());//SimpleFieldAssign//sourceId:2035652_1
        }

        /*D2获取消息问答列表[10425]   */
        Assert.isNull(queryMemorysBusinessDataListComReqDto.getBusinessDataObject(), "D2组装资源文件提问列表-D2获取消息问答列表-业务数据对象不能为空", false);
        Assert.isNull(queryMemorysBusinessDataListComReqDto.getDataObjectBatchCode(), "D2组装资源文件提问列表-D2获取消息问答列表-数据对象批次标识不能为空", false);
        Assert.isNull(queryMemorysBusinessDataListComReqDto.getCustomField1(), "D2组装资源文件提问列表-D2获取消息问答列表-自定义字段1不能为空", false);
        Assert.isNull(queryMemorysBusinessDataListComReqDto.getCustomField2(), "D2组装资源文件提问列表-D2获取消息问答列表-自定义字段2不能为空", false);
        queryMemorysBusinessDataListComRespDto = interfaceModeService.queryMemorysBusinessDataListCom(queryMemorysBusinessDataListComReqDto)/*vcase invoke isSameApp*/;


        queryMemorysBusinessDataListComRespDto_1 = queryMemorysBusinessDataListComRespDto;

        AssembleFileQListComRespDto retData = new AssembleFileQListComRespDto();
        if (queryMemorysBusinessDataListComRespDto_1 != null) {
            retData.setOutputBusinessDataList(queryMemorysBusinessDataListComRespDto_1.getMemoryBusinessResDataList().stream().map(item -> BeanUtil.toBean(item, OutputBusinessDataDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:2035663_1
        }


        return retData;
    }

    /**
     * D2获取阿里云文件(公共)[10445]
     * gen by moon at 12/10/2024, 12:01:08 AM
     */
    @Trace(operationName = "D2获取阿里云文件(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public LoadAliYunFileComRespDto loadAliYunFileCom(LoadAliYunFileComReqDto reqDto) {


        //步骤0: M2从阿里云加载文件到内存（特殊方法） - loadFileFromAliYun
        //ModelCode: loadFileToMemory
        LoadFileFromAliYunRespDto loadFileToMemoryRes = null;
        LoadFileFromAliYunReqDto loadFileToMemoryReq = new LoadFileFromAliYunReqDto();
        if (reqDto != null) {
            loadFileToMemoryReq.setAliyunOssServiceAddress(reqDto.getAliyunOssServiceAddress());//SimpleFieldAssign//sourceId:2035013_1
            loadFileToMemoryReq.setAliyunOssKey(reqDto.getAliyunOssKey());//SimpleFieldAssign//sourceId:2035014_1
            loadFileToMemoryReq.setAliyunOssSecretKey(reqDto.getAliyunOssSecretKey());//SimpleFieldAssign//sourceId:2035015_1
            loadFileToMemoryReq.setAliyunOssBucketName(reqDto.getAliyunOssBucketName());//SimpleFieldAssign//sourceId:2035016_1
            loadFileToMemoryReq.setFile(reqDto.getFile());//SimpleFieldAssign//sourceId:2035017_1
        }

        /*M2从阿里云加载文件到内存（特殊方法）[10442]   */
        Assert.isNull(loadFileToMemoryReq.getAliyunOssServiceAddress(), "D2获取阿里云文件(公共)-M2从阿里云加载文件到内存（特殊方法）-阿里云OSS服务地址不能为空", false);
        Assert.isNull(loadFileToMemoryReq.getAliyunOssKey(), "D2获取阿里云文件(公共)-M2从阿里云加载文件到内存（特殊方法）-阿里云OSS的钥匙不能为空", false);
        Assert.isNull(loadFileToMemoryReq.getAliyunOssSecretKey(), "D2获取阿里云文件(公共)-M2从阿里云加载文件到内存（特殊方法）-阿里云OSS的密钥不能为空", false);
        Assert.isNull(loadFileToMemoryReq.getAliyunOssBucketName(), "D2获取阿里云文件(公共)-M2从阿里云加载文件到内存（特殊方法）-阿里云OSS桶名字不能为空", false);
        Assert.isNull(loadFileToMemoryReq.getFile(), "D2获取阿里云文件(公共)-M2从阿里云加载文件到内存（特殊方法）-文件不能为空", false);
        loadFileToMemoryRes = nbResourceFile.loadFileFromAliYun(loadFileToMemoryReq);


        LoadAliYunFileComRespDto retData = new LoadAliYunFileComRespDto();


        return retData;
    }

    /**
     * D2获取minio文件(公共)[10446]
     * gen by moon at 12/10/2024, 12:01:25 AM
     */
    @Trace(operationName = "D2获取minio文件(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public LoadMinioFileComRespDto loadMinioFileCom(LoadMinioFileComReqDto reqDto) {


        //步骤0: M2从minio加载文件到内存（特殊方法） - loadFileFromMinio
        //ModelCode: loadFileToMemory
        LoadFileFromMinioRespDto loadFileToMemoryRes = null;
        LoadFileFromMinioReqDto loadFileToMemoryReq = new LoadFileFromMinioReqDto();
        if (reqDto != null) {
            loadFileToMemoryReq.setMinioServiceAddress(reqDto.getMinioServiceAddress());//SimpleFieldAssign//sourceId:2035023_1
            loadFileToMemoryReq.setMinioKey(reqDto.getMinioKey());//SimpleFieldAssign//sourceId:2035024_1
            loadFileToMemoryReq.setMinioSecretKey(reqDto.getMinioSecretKey());//SimpleFieldAssign//sourceId:2035025_1
            loadFileToMemoryReq.setMinioBucketName(reqDto.getMinioBucketName());//SimpleFieldAssign//sourceId:2035026_1
            loadFileToMemoryReq.setFile(reqDto.getFile());//SimpleFieldAssign//sourceId:2035027_1
        }

        /*M2从minio加载文件到内存（特殊方法）[10443]   */
        Assert.isNull(loadFileToMemoryReq.getMinioServiceAddress(), "D2获取minio文件(公共)-M2从minio加载文件到内存（特殊方法）-MINIO服务地址不能为空", false);
        Assert.isNull(loadFileToMemoryReq.getMinioKey(), "D2获取minio文件(公共)-M2从minio加载文件到内存（特殊方法）-MINIO的钥匙不能为空", false);
        Assert.isNull(loadFileToMemoryReq.getMinioSecretKey(), "D2获取minio文件(公共)-M2从minio加载文件到内存（特殊方法）-MINIO的密钥不能为空", false);
        Assert.isNull(loadFileToMemoryReq.getMinioBucketName(), "D2获取minio文件(公共)-M2从minio加载文件到内存（特殊方法）-MINIO桶名字不能为空", false);
        Assert.isNull(loadFileToMemoryReq.getFile(), "D2获取minio文件(公共)-M2从minio加载文件到内存（特殊方法）-文件不能为空", false);
        loadFileToMemoryRes = nbResourceFile.loadFileFromMinio(loadFileToMemoryReq);


        LoadMinioFileComRespDto retData = new LoadMinioFileComRespDto();


        return retData;
    }

    /**
     * D2获取本地文件(公共)[10447]
     * gen by moon at 12/15/2024, 4:49:45 PM
     */
    @Trace(operationName = "D2获取本地文件(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public LoadLocalFileComRespDto loadLocalFileCom(LoadLocalFileComReqDto reqDto) {


        //步骤0: M2从本地加载文件到内存（特殊方法） - loadFileFromLocal
        //ModelCode: loadFileToMemory
        LoadFileFromLocalRespDto loadFileToMemoryRes = null;
        LoadFileFromLocalReqDto loadFileToMemoryReq = new LoadFileFromLocalReqDto();
        if (reqDto != null) {
            loadFileToMemoryReq.setFile(reqDto.getFile());//SimpleFieldAssign//sourceId:2035033_1
            loadFileToMemoryReq.setLocalStorageRootPath(reqDto.getLocalStorageRootPath());//SimpleFieldAssign//sourceId:2037008_1
        }

        /*M2从本地加载文件到内存（特殊方法）[10444]   */
        Assert.isNull(loadFileToMemoryReq.getFile(), "D2获取本地文件(公共)-M2从本地加载文件到内存（特殊方法）-文件不能为空", false);
        Assert.isNull(loadFileToMemoryReq.getLocalStorageRootPath(), "D2获取本地文件(公共)-M2从本地加载文件到内存（特殊方法）-本地存储根路径不能为空", false);
        loadFileToMemoryRes = nbResourceFile.loadFileFromLocal(loadFileToMemoryReq);


        LoadLocalFileComRespDto retData = new LoadLocalFileComRespDto();


        return retData;
    }
    //
}
